﻿using UnityEngine;
using System.IO;
using UnityEditor;
using System.Collections.Generic;
using System;
using SoarD.Pandora;
using Object = UnityEngine.Object;

namespace SoarDEditor.Pandora
{
    public class AtlasEditorHelper
    {
    //    public static SpritesheetCollection spriteSheets = new SpritesheetCollection();
    //    public static Type AtlasHierarchy;
    //    public static Type PaddingData;
    //    public static Type PandoraAtlasExtends;
    //    protected static string TexturePackerBatPath
    //    {
    //        get
    //        {
    //            string stuffix;
    //            switch (Application.platform)
    //            {
    //                case RuntimePlatform.OSXEditor:
    //                    stuffix = ".sh";
    //                    break;
    //                case RuntimePlatform.WindowsEditor:
    //                    stuffix = ".bat";
    //                    break;
    //                default:
    //                    Debug.LogError("错误平台");
    //                    return "";
    //            }

				//string fullpath = FindBase.GetFullPath("Tools/TexturePacker/maker" + stuffix);

				//switch (Application.platform)
				//{
				//case RuntimePlatform.OSXEditor:
				//	PdrCMDHelper.ProcessCommandEx ("chmod", string.Format ("+x {0}", fullpath));
				//	break;
				//}

				//return fullpath;
    //        }
    //    }


    //    public enum Step
    //    {
    //        MAKE_ATLAS = 1 << 0,
    //        SPLIT_CHANNEL = 1 << 2,
    //        CREATE_MATERIAL = 1 << 3,
    //        IMPORT_SPRITE = 1 << 4,
    //        CREATE_PREFAB = 1 << 5,
    //        MAKE_POLY_ATLAS = 1 << 6,
    //        SPLIT_CHANNEL_POLY = 1 << 7,
    //        IMPORT_POLY_SPRITE = 1 << 8,
    //        CREATE_POLY_PREFAB = 1 << 9,

    //        ALL = MAKE_ATLAS | SPLIT_CHANNEL | CREATE_MATERIAL | IMPORT_SPRITE | CREATE_PREFAB,
    //        ALL_POLY = MAKE_POLY_ATLAS | SPLIT_CHANNEL_POLY | CREATE_MATERIAL | IMPORT_POLY_SPRITE | CREATE_POLY_PREFAB,
    //    }
    //    static string GetTexturePackerBatPath(string name){
    //            string stuffix;
    //            switch (Application.platform)
    //            {
    //                case RuntimePlatform.OSXEditor:
    //                    stuffix = ".sh";
    //                    break;
    //                case RuntimePlatform.WindowsEditor:
    //                    stuffix = ".bat";
    //                    break;
    //                default:
    //                    Debug.LogError("错误平台");
    //                    return "";
    //            }

				//string fullpath = FindBase.GetFullPath("Tools/TexturePacker/"+ name + stuffix);

				//switch (Application.platform)
				//{
				//case RuntimePlatform.OSXEditor:
				//	PdrCMDHelper.ProcessCommandEx ("chmod", string.Format ("+x {0}", fullpath));
				//	break;
				//}

				//return fullpath;
    //    }
    //    public static void Build(Step step, string name, string pathSrc, string pathTmp, string pathDst, bool trim = false, bool isCompress = true, bool isSplitChannel = true, bool isUI = true)
    //    {
    //        if ((step & Step.MAKE_ATLAS) != 0)
    //        {
    //            MakeAtlas(name, pathSrc, pathTmp, trim);
    //        }
    //        if ((step & Step.SPLIT_CHANNEL) != 0)
    //        {
    //            SplitChannel(name, pathTmp, pathDst, isCompress, isSplitChannel);
    //        }
    //        if ((step & Step.CREATE_MATERIAL) != 0)
    //        {
    //            CreateMaterial(name, pathDst, isUI, isSplitChannel);
    //        }
    //        if ((step & Step.IMPORT_SPRITE) != 0)
    //        {
    //            ImportSprite(name, pathSrc, pathTmp, pathDst, isCompress);
    //        }
    //        if ((step & Step.CREATE_PREFAB) != 0)
    //        {
    //            CreateSpritePrefab(name, pathDst, pathTmp);
    //        }
    //        if ((step & Step.MAKE_POLY_ATLAS) != 0)
    //        {
    //            MakePolyAtlas(name, pathSrc, pathTmp);
    //        }
    //        if ((step & Step.SPLIT_CHANNEL_POLY) != 0)
    //        {
    //            SplitPolyChannel(name, pathTmp, pathDst, isCompress, isSplitChannel);
    //        }
    //        if ((step & Step.IMPORT_POLY_SPRITE) != 0)
    //        {
    //            ImportPolySprite(name, pathSrc, pathTmp, pathDst, isCompress);
    //        }
    //        if ((step & Step.CREATE_POLY_PREFAB) != 0)
    //        {
    //            CreatePolySpritePrefab(name, pathSrc, pathDst, pathTmp);
    //        }
            
    //    }
    //    public static void MakePolyAtlas(string name, string pathSrc, string pathDst){
    //        string fullPathDst = string.Format("{0}/{1}_c", pathDst, name);
            
    //        if (!Directory.Exists(pathSrc))
    //        {
    //            Debug.LogError(string.Format("No Found Atlas Path: {0}", pathSrc));
    //            return;
    //        }
    //        var TexturePackerBatPath = GetTexturePackerBatPath("maker_Poly");
    //        if (string.IsNullOrEmpty(TexturePackerBatPath))
    //        {
    //            return;
    //        }

    //        int padding = 0;
    //        string args = string.Format("{0} {1} {2}", pathSrc, fullPathDst, padding);
    //        string error = PdrCMDHelper.ProcessCommand(TexturePackerBatPath, args);
    //        if (!string.IsNullOrEmpty(error))
    //        {
    //            Debug.LogError(string.Format("Make Atlas Error. name:{0}, msg:{1}", name, error));
    //        }
    //        AssetDatabase.Refresh();

    //        string pathTxt = string.Format("{0}.tpsheet", fullPathDst);
    //        if (!File.Exists(pathTxt))
    //        {
    //            Debug.LogError(string.Format("TexturePacker Config No Exist: {0}", name));
    //            return;
    //        }
    //    }
    //    public static void MakeAtlas(string name, string pathSrc, string pathDst, bool trim)
    //    {
    //        string fullPathDst = string.Format("{0}/{1}", pathDst, name);
            
    //        if (!Directory.Exists(pathSrc))
    //        {
    //            Debug.LogError(string.Format("No Found Atlas Path: {0}", pathSrc));
    //            return;
    //        }
            
    //        var TexturePackerBatPath = GetTexturePackerBatPath("maker");
    //        if (string.IsNullOrEmpty(TexturePackerBatPath))
    //        {
    //            return;
    //        }

    //        int padding = 0;
    //        string args = string.Format("{0} {1} {2} {3}", pathSrc, fullPathDst, trim ? 1 : 0, padding);
    //        string error = PdrCMDHelper.ProcessCommand(TexturePackerBatPath, args);
    //        if (!string.IsNullOrEmpty(error))
    //        {
    //            Debug.LogError(string.Format("Make Atlas Error. name:{0}, msg:{1}", name, error));
    //        }
    //        AssetDatabase.Refresh();

    //        string pathTxt = string.Format("{0}.txt", fullPathDst);
    //        if (!File.Exists(pathTxt))
    //        {
    //            Debug.LogError(string.Format("TexturePacker Config No Exist: {0}", name));
    //            return;
    //        }
    //        string path = string.Format("{0}.png", fullPathDst);
    //        TextureImporter importer = (TextureImporter)AssetImporter.GetAtPath(path);
    //        importer.textureType = TextureImporterType.Default;
    //        importer.isReadable = true;
    //        importer.alphaSource = TextureImporterAlphaSource.FromInput;
    //        importer.maxTextureSize = 2048;
    //        importer.textureCompression = TextureImporterCompression.Uncompressed;
    //        importer.SaveAndReimport();
    //        AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
    //        AssetDatabase.Refresh();
    //    }
    //    public static void SplitPolyChannel(string name, string pathSrc, string pathDst, bool isCompress, bool isSplitChannel)
    //    {
    //        string path = string.Format("{0}/{1}_c.png", pathSrc, name);
    //        string pathSrcTpSheet = string.Format("{0}/{1}_c.tpsheet", pathSrc, name);
    //        string pathTpSheet = string.Format("{0}/{1}_c.tpsheet", pathDst, name);
    //        string pathColor = string.Format("{0}/{1}_c.png", pathDst, name);
    //        string pathAlpha = string.Format("{0}/{1}_a.png", pathDst, name);

    //        if (!Directory.Exists(pathDst))
    //        {
    //            Directory.CreateDirectory(pathDst);
    //        }

    //        Texture2D texture = AssetDatabase.LoadAssetAtPath<Texture2D>(path);
    //        TextureImporter importTex = (TextureImporter)AssetImporter.GetAtPath(path);
    //        if (importTex == null)
    //        {
    //            Debug.LogError(path + "is null");
    //            return;
    //        }
    //        bool isChangeImporter = false;
    //        if (!importTex.isReadable)
    //        {
    //            importTex.isReadable = true;
    //            isChangeImporter = true;
    //        }
    //        if (importTex.alphaSource != TextureImporterAlphaSource.FromInput)
    //        {
    //            importTex.alphaSource = TextureImporterAlphaSource.FromInput;
    //            isChangeImporter = true;
    //        }
    //        if (isChangeImporter)
    //        {
    //            importTex.SaveAndReimport();
    //        }
    //        if (isSplitChannel)
    //        {
    //            Texture2D textureAlpha = new Texture2D(texture.width, texture.height);
    //            Texture2D textureColor = new Texture2D(texture.width, texture.height);

    //            for (int i = 0; i < texture.width; ++i)
    //            {
    //                for (int j = 0; j < texture.height; ++j)
    //                {
    //                    Color color = texture.GetPixel(i, j);
    //                    textureAlpha.SetPixel(i, j, new Color(color.a, color.a, color.a));
    //                    textureColor.SetPixel(i, j, new Color(color.r, color.g, color.b));
    //                }
    //            }

    //            File.WriteAllBytes(pathColor, textureColor.EncodeToPNG());
    //            File.WriteAllBytes(pathAlpha, textureAlpha.EncodeToPNG());
    //            File.Copy(pathSrcTpSheet,pathTpSheet,true);
    //        }
    //        else
    //        {
    //            Texture2D textureColor = new Texture2D(texture.width, texture.height);

    //            for (int i = 0; i < texture.width; ++i)
    //            {
    //                for (int j = 0; j < texture.height; ++j)
    //                {
    //                    Color color = texture.GetPixel(i, j);
    //                    textureColor.SetPixel(i, j, new Color(color.r, color.g, color.b, color.a));
    //                }
    //            }
    //            File.WriteAllBytes(pathColor, textureColor.EncodeToPNG());
    //            if (File.Exists(pathAlpha))
    //            {
    //                File.Delete(pathAlpha);
    //            }
    //        }
    //        AssetDatabase.Refresh();
            
    //        if (isSplitChannel)
    //        {
    //            TextureImporter importAlpha = (TextureImporter)AssetImporter.GetAtPath(pathAlpha);
    //            importAlpha.textureType = TextureImporterType.Default;
    //            importAlpha.mipmapEnabled = false;
    //            importAlpha.isReadable = false;
    //            importAlpha.alphaSource = TextureImporterAlphaSource.None;
    //            importAlpha.textureCompression = isCompress ? TextureImporterCompression.Compressed : TextureImporterCompression.Uncompressed;
    //            int scale = AtlasConfig.GetAtlasAphlaScale(name);
    //            importAlpha.maxTextureSize = texture.width / scale;
    //            importAlpha.filterMode = FilterMode.Bilinear;
    //            importAlpha.SaveAndReimport();
    //        }
    //        else
    //        {
    //            TextureImporter importColor = (TextureImporter)AssetImporter.GetAtPath(pathColor);
    //            importColor.textureType = TextureImporterType.Default;
    //            importColor.mipmapEnabled = false;
    //            importColor.isReadable = false;
    //            importColor.alphaSource = TextureImporterAlphaSource.FromInput;
    //            importColor.textureCompression = isCompress ? TextureImporterCompression.Compressed : TextureImporterCompression.Uncompressed;
    //            importColor.maxTextureSize = texture.width;
    //            importColor.filterMode = FilterMode.Bilinear;
    //            importColor.SaveAndReimport();
    //        }
    //        AssetDatabase.Refresh();

    //        // File.Delete(pathTpSheet);
    //    }
    //    public static void SplitChannel(string name, string pathSrc, string pathDst, bool isCompress, bool isSplitChannel)
    //    {
    //        string path = string.Format("{0}/{1}.png", pathSrc, name);
    //        string pathColor = string.Format("{0}/{1}_c.png", pathDst, name);
    //        string pathAlpha = string.Format("{0}/{1}_a.png", pathDst, name);
    //        string pathTpSheet = string.Format("{0}/{1}_c.tpsheet", pathDst, name);
    //        if(File.Exists(pathTpSheet)){
    //            File.Delete(pathTpSheet);
    //        }

    //        if (!Directory.Exists(pathDst))
    //        {
    //            Directory.CreateDirectory(pathDst);
    //        }

    //        Texture2D texture = AssetDatabase.LoadAssetAtPath<Texture2D>(path);
    //        TextureImporter importTex = (TextureImporter)AssetImporter.GetAtPath(path);
    //        if (importTex == null)
    //        {
    //            Debug.LogError(path + "is null");
    //            return;
    //        }
    //        bool isChangeImporter = false;
    //        if (!importTex.isReadable)
    //        {
    //            importTex.isReadable = true;
    //            isChangeImporter = true;
    //        }
    //        if (importTex.alphaSource != TextureImporterAlphaSource.FromInput)
    //        {
    //            importTex.alphaSource = TextureImporterAlphaSource.FromInput;
    //            isChangeImporter = true;
    //        }
    //        if (isChangeImporter)
    //        {
    //            importTex.SaveAndReimport();
    //        }
    //        if (isSplitChannel)
    //        {
    //            Texture2D textureColor = new Texture2D(texture.width, texture.height);
    //            Texture2D textureAlpha = new Texture2D(texture.width, texture.height);

    //            for (int i = 0; i < texture.width; ++i)
    //            {
    //                for (int j = 0; j < texture.height; ++j)
    //                {
    //                    Color color = texture.GetPixel(i, j);
    //                    textureAlpha.SetPixel(i, j, new Color(color.a, color.a, color.a));
    //                    textureColor.SetPixel(i, j, new Color(color.r, color.g, color.b));
    //                }
    //            }

    //            File.WriteAllBytes(pathColor, textureColor.EncodeToPNG());
    //            File.WriteAllBytes(pathAlpha, textureAlpha.EncodeToPNG());
    //        }
    //        else
    //        {
    //            Texture2D textureColor = new Texture2D(texture.width, texture.height);

    //            for (int i = 0; i < texture.width; ++i)
    //            {
    //                for (int j = 0; j < texture.height; ++j)
    //                {
    //                    Color color = texture.GetPixel(i, j);
    //                    textureColor.SetPixel(i, j, new Color(color.r, color.g, color.b, color.a));
    //                }
    //            }
    //            File.WriteAllBytes(pathColor, textureColor.EncodeToPNG());
    //            if (File.Exists(pathAlpha))
    //            {
    //                File.Delete(pathAlpha);
    //            }
    //        }

    //        AssetDatabase.Refresh();

    //        if (isSplitChannel)
    //        {
    //            TextureImporter importAlpha = (TextureImporter)AssetImporter.GetAtPath(pathAlpha);
    //            importAlpha.textureType = TextureImporterType.Default;
    //            importAlpha.mipmapEnabled = false;
    //            importAlpha.isReadable = false;
    //            importAlpha.alphaSource = TextureImporterAlphaSource.None;
    //            importAlpha.textureCompression = isCompress ? TextureImporterCompression.Compressed : TextureImporterCompression.Uncompressed;
    //            int scale = AtlasConfig.GetAtlasAphlaScale(name);
    //            importAlpha.maxTextureSize = texture.width / scale;
    //            importAlpha.filterMode = FilterMode.Bilinear;
    //            importAlpha.SaveAndReimport();
    //        }
    //        else
    //        {
    //            TextureImporter importColor = (TextureImporter)AssetImporter.GetAtPath(pathColor);
    //            importColor.textureType = TextureImporterType.Default;
    //            importColor.mipmapEnabled = false;
    //            importColor.isReadable = false;
    //            importColor.alphaSource = TextureImporterAlphaSource.FromInput;
    //            importColor.textureCompression = isCompress ? TextureImporterCompression.Compressed : TextureImporterCompression.Uncompressed;
    //            importColor.maxTextureSize = texture.width;
    //            importColor.filterMode = FilterMode.Bilinear;
    //            importColor.SaveAndReimport();
    //        }
    //        AssetDatabase.Refresh();
            
    //    }
    //    static void CreateMaterial(string name, string pathDst, bool isUI, bool isSplitChannel)
    //    {
    //        string pathColor = string.Format("{0}/{1}_c.png", pathDst, name);
    //        string pathAlpha = string.Format("{0}/{1}_a.png", pathDst, name);
    //        string pathMaterial = string.Format("{0}/{1}_mat.mat", pathDst, name);

    //        Texture2D textureColor = AssetDatabase.LoadAssetAtPath<Texture2D>(pathColor);
    //        Texture2D textureAlpha = AssetDatabase.LoadAssetAtPath<Texture2D>(pathAlpha);

    //        string shaderName;
    //        if (isUI)
    //        {
    //            if (isSplitChannel)
    //            {
    //                shaderName = "UI/Default(RGB+A)";
    //            }
    //            else
    //            {
    //                shaderName = "UI/Default(ARGB)";
    //            }
    //        }
    //        else
    //        {
    //            shaderName = "Custom/Transparent/Diffuse(RGB+A)_Lambert";
    //        }
    //        Shader shader = Shader.Find(shaderName);
    //        Material material = null;
    //        if (File.Exists(pathMaterial))
    //        {
    //            material = AssetDatabase.LoadAssetAtPath<Material>(pathMaterial);
    //            material.shader = shader;
    //        }
    //        else
    //        {
    //            material = new Material(shader);
    //        }
    //        //todo: 真彩的时候这里是错的要改...
    //        material.SetTexture("_MainTex", textureColor);
    //        material.SetTexture("_AlphaTex", textureAlpha);

    //        if (File.Exists(pathMaterial))
    //        {
    //            EditorUtility.SetDirty(material);
    //            AssetDatabase.SaveAssets();
    //        }
    //        else
    //        {
    //            AssetDatabase.CreateAsset(material, pathMaterial);
    //        }
    //    }
    //    public static void ImportSprite(string name, string pathSrc, string pathTP, string pathDst,bool isCompress)
    //    {

    //        string pathTxt = string.Format("{0}/{1}.txt", pathTP, name);

    //        if (!File.Exists(pathTxt))
    //        {
    //            Debug.LogError(string.Format("TexturePacker Config No Exist: {0}", pathTxt));
    //            return;
    //        }
    //        string text = PdrFileUtil.ReadTextFromFile(pathTxt);

    //        string pathTexture = string.Format("{0}/{1}_c.png", pathDst, name);
    //        TextureImporter importer = AssetImporter.GetAtPath(pathTexture) as TextureImporter;
    //        if (importer == null)
    //        {
    //            Debug.LogError(pathTexture + ":is null");
    //            return;
    //        }
    //        List<SpriteMetaData> sprites = TexturePacker.ProcessToSprites(text);
    //        RewriteInfo(sprites, pathSrc);
    //        importer.spritesheet = sprites.ToArray();
    //        importer.textureType = TextureImporterType.Sprite;
    //        importer.spriteImportMode = SpriteImportMode.Multiple;
    //        importer.sRGBTexture = true;
    //        importer.filterMode = FilterMode.Bilinear;
    //        importer.spritePackingTag = null;
    //        importer.mipmapEnabled = false;
    //        importer.isReadable = false;
    //        importer.maxTextureSize = 2048;
    //        if (isCompress)
    //        {
    //            importer.alphaSource = TextureImporterAlphaSource.None;
    //            importer.textureCompression = TextureImporterCompression.Compressed;
    //        }
    //        else
    //        {
    //            importer.alphaSource = TextureImporterAlphaSource.FromInput;
    //            importer.textureCompression = TextureImporterCompression.Uncompressed;
    //        }
    //        importer.SaveAndReimport();
    //        AssetDatabase.ImportAsset(pathTexture, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
    //        AssetDatabase.Refresh();
    //    }
    //    private static void RewriteInfo(List<SpriteMetaData> sprites, string pathSrc)
    //    {
    //        string[] strDirectorys = null;
    //        for (int i = 0; i < sprites.Count; ++i)
    //        {
    //            SpriteMetaData data = sprites[i];
    //            string pathTexture = string.Format("{0}/{1}.png", pathSrc, data.name);
    //            TextureImporter importer = AssetImporter.GetAtPath(pathTexture) as TextureImporter;
    //            if (importer == null)
    //            {   
    //                // 取不到，可能是有子目录，从子目录再找下看看
    //                if (strDirectorys == null)
    //                    strDirectorys = GetTopDirectory(pathSrc);

    //                if (strDirectorys == null)
    //                    continue;

    //                for (int j = 0; j < strDirectorys.Length; ++j)
    //                {
    //                    pathTexture = string.Format("{0}/{1}/{2}.png", pathSrc, strDirectorys[j], data.name);
    //                    importer = AssetImporter.GetAtPath(pathTexture) as TextureImporter;
    //                    if (importer){
    //                        break;
    //                    }
    //                }
                    
    //                if (importer == null)
    //                    continue;
    //            }

    //            data.border = importer.spriteBorder;
    //            if (data.alignment != 9)
    //            {
    //                data.pivot = importer.spritePivot;
    //            }
    //            sprites[i] = data;
    //        }
    //    }
    //    public static void ImportPolySprite(string name, string pathSrc, string pathTP, string pathDst,bool isCompress)
    //    {
    //        string pathTpSheet = string.Format("{0}/{1}_c.tpsheet", pathTP, name);
    //        string pathTpScr = string.Format("{0}/{1}_c.png", pathTP, name);

    //        if (!File.Exists(pathTpSheet))
    //        {
    //            Debug.LogError(string.Format("TexturePacker Poly Scr No Exist: {0}", pathTpSheet));
    //            return;
    //        }
    //        if(spriteSheets.loadSheetData(pathTpSheet) == LoaderResult.Error){
    //            Debug.LogError(string.Format("TexturePacker Poly load fail: {0}", pathTpSheet));
    //            return;
    //        }

    //        SheetInfo sheetInfo = spriteSheets.sheetInfoForSpriteFile(pathTpScr);
    //        List<SpriteMetaData> sprites = new List<SpriteMetaData>(sheetInfo.metadata);
    //        RewriteInfo(sprites, pathSrc);

    //        string pathTexture = string.Format("{0}/{1}_c.png", pathDst, name);
    //        TextureImporter importer = AssetImporter.GetAtPath(pathTexture) as TextureImporter;
    //        if (importer == null)
    //        {
    //            Debug.LogError(pathTexture + ":is null");
    //            return;
    //        }
    //        importer.spritesheet = sprites.ToArray();
    //        importer.textureType = TextureImporterType.Sprite;
    //        importer.spriteImportMode = SpriteImportMode.Multiple;
    //        importer.sRGBTexture = true;
    //        importer.filterMode = FilterMode.Bilinear;
    //        importer.spritePackingTag = null;
    //        importer.mipmapEnabled = false;
    //        importer.isReadable = false;
    //        importer.maxTextureSize = 2048;
    //        if (isCompress)
    //        {
    //            importer.alphaSource = TextureImporterAlphaSource.None;
    //            importer.textureCompression = TextureImporterCompression.Compressed;
    //        }
    //        else
    //        {
    //            importer.alphaSource = TextureImporterAlphaSource.FromInput;
    //            importer.textureCompression = TextureImporterCompression.Uncompressed;
    //        }
    //        importer.SaveAndReimport();
    //        AssetDatabase.ImportAsset(pathTexture, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
    //        AssetDatabase.Refresh();
    //    }
        
    //    // 取子目录
    //    private static string[] GetTopDirectory(string pathSrc)
    //    {   
    //        DirectoryInfo direction = new DirectoryInfo(pathSrc);  
    //        FileInfo[] files = direction.GetFiles("*", SearchOption.TopDirectoryOnly);  
    //        if(files.Length <= 0)
    //            return null;

    //        string[] strDirectorys = new String[files.Length];
    //        for (int i = 0; i < files.Length; ++i)
    //        {   
    //            strDirectorys.SetValue(files[i].Name.Replace(".meta",""),i);
    //        }
            
    //        return strDirectorys;
    //    }

    //    static void CreateSpritePrefab(string name, string path, string pathTP)
    //    {
    //        string pathPrefab = string.Format("{0}/{1}.prefab", path, name);
    //        string pathColor = string.Format("{0}/{1}_c.png", path, name);
    //        string pathMaterial = string.Format("{0}/{1}_mat.mat", path, name);

    //        if (!File.Exists(pathColor))
    //        {
    //            Debug.LogError(string.Format("File No Found: {0}", pathColor));
    //            return;
    //        }

    //        if (!File.Exists(pathMaterial))
    //        {
    //            Debug.LogError(string.Format("File No Found: {0}", pathMaterial));
    //            return;
    //        }

    //        string pathTxt = string.Format("{0}/{1}.txt", pathTP, name);
    //        string text = PdrFileUtil.ReadTextFromFile(pathTxt);
    //        List<TexturePacker.PackedFrame> frames = TexturePacker.ProcessToFrames(text);

    //        SpriteMetaData meta;
    //        Dictionary<string, SpriteMetaData> metas = new Dictionary<string, SpriteMetaData>();

    //        TextureImporter importer = AssetImporter.GetAtPath(pathColor) as TextureImporter;

    //        for (int i = 0; i < importer.spritesheet.Length; ++i)
    //        {
    //            meta = importer.spritesheet[i];
    //            if (metas.ContainsKey(meta.name))
    //                Debug.LogError("key is already exist the dictionary:  " + meta.name);
    //            metas.Add(meta.name, meta);
    //        }
    //        //AtlasData data = new AtlasData();
    //        //data.material = AssetDatabase.LoadAssetAtPath<Material>(pathMaterial);
    //        //data.sprites = new List<AtlasData.SpriteData>();
    //        Material mat = AssetDatabase.LoadAssetAtPath<Material>(pathMaterial);

    //        List<Sprite> sprites = new List<Sprite>();
    //        List<Vector4> rts = new List<Vector4>();
    //        List<bool> trims = new List<bool>();

    //        Sprite sprite = null;
    //        UnityEngine.Object[] objects = AssetDatabase.LoadAllAssetRepresentationsAtPath(pathColor);
    //        for (int i = 0; i < objects.Length; ++i)
    //        {
    //            sprite = objects[i] as Sprite;
    //            if (sprite == null) continue;

    //            bool trim = false;
    //            if (metas.TryGetValue(sprite.name, out meta))
    //            {
    //                trim = meta.alignment == 9;
    //            }

    //            Vector4 rt = Vector4.zero;
    //            foreach (TexturePacker.PackedFrame frame in frames)
    //            {
    //                string spritename = frame.name.Replace(".png", "");
    //                if (string.Equals(spritename, sprite.name))
    //                {
    //                    float left = frame.spriteSourceSize.x;
    //                    float top = frame.spriteSourceSize.y;
    //                    float right = frame.sourceSize.x - frame.spriteSourceSize.x - frame.spriteSourceSize.width;
    //                    float bottom = frame.sourceSize.y - frame.spriteSourceSize.y - frame.spriteSourceSize.height;

    //                    rt.x = left;
    //                    rt.y = bottom;
    //                    rt.z = right;
    //                    rt.w = top;
    //                    break;
    //                }
    //            }
    //            sprites.Add(sprite);
    //            rts.Add(rt);
    //            trims.Add(trim);
    //            //data.sprites.Add(new AtlasData.SpriteData(sprite, rt, trim));
    //        }

    //        GameObject prefab = null;
    //        GameObject go = null;
    //        if (File.Exists(pathPrefab))
    //        {
    //            prefab = AssetDatabase.LoadAssetAtPath<GameObject>(pathPrefab);
    //            go = Object.Instantiate(prefab);
    //        }
    //        else
    //        {
    //            go = new GameObject();
    //        }

    //        go.name = name;

    //        var hierarchy = go.GetComponent(AtlasHierarchy) ?? go.AddComponent(AtlasHierarchy);

    //        AtlasHierarchy_SetAtlasData(hierarchy,sprites,rts,trims, mat);
    //        //hierarchy.atlas = data;

    //        if (path.Contains(Config.UI_PATH + "/atlas_tp"))
    //        {
    //            BuildOnePaddingData(name, false, hierarchy);   
    //        }

    //        if (prefab != null)
    //        {
    //            PrefabUtility.ReplacePrefab(go, prefab);
    //        }
    //        else
    //        {
    //            PrefabUtility.CreatePrefab(pathPrefab, go);
    //        }
    //        Object.DestroyImmediate(go);
    //    }
    //    static void CreatePolySpritePrefab(string name, string pathScr, string pathDst, string pathTP)
    //    {
    //        string pathPrefab = string.Format("{0}/{1}.prefab", pathDst, name);
    //        string pathColor = string.Format("{0}/{1}_c.png", pathDst, name);
    //        string pathMaterial = string.Format("{0}/{1}_mat.mat", pathDst, name);
    //        string pathTpScr = string.Format("{0}/{1}.png", pathTP, name);

    //        if (!File.Exists(pathColor))
    //        {
    //            Debug.LogError(string.Format("File No Found: {0}", pathColor));
    //            return;
    //        }

    //        if (!File.Exists(pathMaterial))
    //        {
    //            Debug.LogError(string.Format("File No Found: {0}", pathMaterial));
    //            return;
    //        }

    //        SpriteMetaData meta;
    //        Dictionary<string, SpriteMetaData> metas = new Dictionary<string, SpriteMetaData>();

    //        TextureImporter importer = AssetImporter.GetAtPath(pathColor) as TextureImporter;

    //        for (int i = 0; i < importer.spritesheet.Length; ++i)
    //        {
    //            meta = importer.spritesheet[i];
    //            if (metas.ContainsKey(meta.name))
    //                Debug.LogError("key is already exist the dictionary:  " + meta.name);
    //            metas.Add(meta.name, meta);
    //        }
    //        Material mat = AssetDatabase.LoadAssetAtPath<Material>(pathMaterial);
    //        List<Sprite> sprites = new List<Sprite>();
    //        List<Vector4> rts = new List<Vector4>();
    //        List<bool> trims = new List<bool>();

    //        var assetObjects = FindBase.GetSourceSprites(pathScr);
    //        Sprite packSprite = null;
    //        UnityEngine.Object[] objects = AssetDatabase.LoadAllAssetRepresentationsAtPath(pathColor);
    //        for (int i = 0; i < objects.Length; ++i)
    //        {
    //            packSprite = objects[i] as Sprite;
    //            if (packSprite == null) continue;

    //            bool trim = false;
    //            if (metas.TryGetValue(packSprite.name, out meta))
    //            {
    //                trim = meta.alignment == 9;
    //            }
    //            //获取padding
    //            Vector4 rt = Vector4.zero;
    //            for (int j = 0; j < assetObjects.Count; j++)
    //            {
    //                Sprite srcSprite = assetObjects[j].sprite;
    //                if (Path.GetFileNameWithoutExtension(assetObjects[j].name) == packSprite.name)
    //                {
    //                    var src_Padding = UnityEngine.Sprites.DataUtility.GetPadding(srcSprite);

    //                    float pack_PivotLeft = packSprite.pivot.x;
    //                    float pack_PivotRight = packSprite.rect.width - pack_PivotLeft;
    //                    float pack_PivotBottom = packSprite.pivot.y;
    //                    float pack_PivotTop = packSprite.rect.height - pack_PivotBottom;

    //                    float src_PivotLeft = srcSprite.pivot.x - src_Padding.x;
    //                    float src_PivotRight = (srcSprite.rect.width - src_Padding.x - src_Padding.z) - src_PivotLeft;
    //                    float src_PivotBottom = srcSprite.pivot.y - src_Padding.y;
    //                    float src_PivotTop = (srcSprite.rect.height - src_Padding.y - src_Padding.w) - src_PivotBottom;

    //                    float d_PivotLeft = pack_PivotLeft - src_PivotLeft;
    //                    float d_PivotRight = pack_PivotRight - src_PivotRight;
    //                    float d_PivotTop = pack_PivotTop - src_PivotTop;
    //                    float d_PivotBottom = pack_PivotBottom - src_PivotBottom;

    //                    rt = new Vector4(src_Padding.x - d_PivotLeft, src_Padding.y - d_PivotBottom, src_Padding.z - d_PivotRight, src_Padding.w - d_PivotTop);

    //                    break;
    //                }
    //            }
                
    //            sprites.Add(packSprite);
    //            rts.Add(rt);
    //            trims.Add(trim);
    //        }

    //        GameObject prefab = null;
    //        GameObject go = null;
    //        if (File.Exists(pathPrefab))
    //        {
    //            prefab = AssetDatabase.LoadAssetAtPath<GameObject>(pathPrefab);
    //            go = Object.Instantiate(prefab);
    //        }
    //        else
    //        {
    //            go = new GameObject();
    //        }

    //        go.name = name;

    //        var hierarchy = go.GetComponent(AtlasHierarchy) ?? go.AddComponent(AtlasHierarchy);

    //        AtlasHierarchy_SetAtlasData(hierarchy,sprites,rts,trims, mat);
    //        //hierarchy.atlas = data;

    //        if (pathDst.Contains(Config.UI_PATH + "/atlas_tp"))
    //        {
    //            BuildOnePaddingData(name, true, hierarchy);   
    //        }

    //        if (prefab != null)
    //        {
    //            PrefabUtility.ReplacePrefab(go, prefab);
    //        }
    //        else
    //        {
    //            PrefabUtility.CreatePrefab(pathPrefab, go);
    //        }
    //        Object.DestroyImmediate(go);
    //    }
    //    public static void BuildOnePaddingData(string name, bool isPoly, Component hierarchy)
    //    {
    //        bool needCreate = false;
    //        string paddingPath = Config.UI_ASSETS_PATH + "/atlas_tp_padding.asset";

    //        PaddingData data = AssetDatabase.LoadAssetAtPath<PaddingData>(paddingPath);
    //        if (data == null)
    //        {
    //            data = ScriptableObject.CreateInstance<PaddingData>();
    //            needCreate = true;
    //        }

    //        //if (data.atlas != null)
    //        //{
    //        //    for (int i = data.atlas.Count - 1; i > 0; i--)
    //        //    {
    //        //        if (data.atlas[i].name == name)
    //        //        {
    //        //            data.atlas.RemoveAt(i);
    //        //        }
    //        //    }
    //        //}
    //        PaddingData_RemoveAtlasItem(data, name);

    //        //List<PaddingData.SpriteInfo> sprites = new List<PaddingData.SpriteInfo>();
    //        //foreach (AtlasData.SpriteData sprite in hierarchy.atlas.sprites)
    //        //{
    //        //    sprites.Add(new PaddingData.SpriteInfo(sprite.name, sprite.padding));
    //        //}

    //        //data.AddAtlas(name, sprites);

    //        List<string> spriteNames = AtlasHierarchy_GetSpriteDataName(hierarchy);
    //        List<Vector4> paddings = AtlasHierarchy_GetSpriteDataPadding(hierarchy);

    //        PaddingData_AddAtlas(data, name, isPoly, spriteNames, paddings);
    //        CheckAtlas(data.atlas);
    //        if (needCreate)
    //        {
    //            AssetDatabase.CreateAsset(data, paddingPath);
    //        }
    //        else
    //        {
    //            EditorUtility.SetDirty(data);
    //            AssetDatabase.SaveAssets();
    //        }
    //        AssetDatabase.Refresh();
    //    }

    //    static void CheckAtlas(List<PaddingData.AtlasInfo> atlas){
    //        for (int i = atlas.Count - 1; i >= 0; i--)
    //        {
    //            string name = atlas[i].name;
    //            var pathAtlasInfo = string.Format("{0}/{1}.prefab", PdrConfig.Instance.AtlasTPPath, name);
    //            var asset = AssetDatabase.LoadAssetAtPath<AtlasHierarchy>(pathAtlasInfo);
    //            if (asset == null)
    //            {
    //                atlas.Remove(atlas[i]);
    //            }
    //        }
    //    }

        #region 反射函数
        //private static void AtlasHierarchy_SetAtlasData(object target, List<Sprite> sprites, List<Vector4> rts, List<bool> trims, Material mat)
        //{
        //    PandoraAtlasExtends.GetMethod("SetAtlasData").Invoke(target, new object[] { target, sprites, rts, trims, mat});
        //}
        //private static List<Vector4> AtlasHierarchy_GetSpriteDataPadding(object target)
        //{
        //    return (List<Vector4>)PandoraAtlasExtends.GetMethod("GetSpriteDataPadding").Invoke(target, new object[] { target });
        //}
        //private static List<string> AtlasHierarchy_GetSpriteDataName(object target)
        //{
        //    return (List<string>)PandoraAtlasExtends.GetMethod("GetSpriteDataName").Invoke(target, new object[] { target });
        //}
        //private static void PaddingData_AddAtlas(object target, string name, bool isPoly, List<string> spriteNames, List<Vector4> paddings)
        //{
        //    PandoraAtlasExtends.GetMethod("AddAtlasEx").Invoke(target, new object[] { target, name, isPoly, spriteNames, paddings });
        //}
        //private static void PaddingData_RemoveAtlasItem(object target, string name)
        //{
        //    PandoraAtlasExtends.GetMethod("RemoveAtlasItem").Invoke(target, new object[] { target, name });
        //}
        #endregion

        public static void PlayProgressBar(string title, string content, float ratio)
        {
            EditorUtility.DisplayProgressBar(title, content, ratio);
        }
        public static void ClearProgressBar()
        {
            EditorUtility.ClearProgressBar();
        }
    }
}
